export function cleanString(str: string) {
  return (str || "")
    .replace(/\s+/g, " ")
    .replace(/\u00A0/g, " ")
    .replace(
      /[\x00-\x1F\x7F-\x9F\u200B-\u200F\u202A-\u202E\u2060-\u206F\uFEFF]/g,
      ""
    )
    .trim();
}
// 归一化重量，兼容 `pounds`, `lbs`, `lb`, `ounces`, `oz` 等
export function normalizeWeight(text: string, marketplace?: string): any {
  let value = cleanString(text);
  if (marketplace) {
    if (["MEX", "FRA", "DEU"].includes(marketplace)) {
      // 将逗号替换为点，但要确保不会影响千位分隔符
      // 例如："5,2 Kilogramos" -> "5.2 kilogramos"
      // 但 "5,200 Gramos" -> "5200 gramos"
      if (
        value.split(",").length - 1 === 1 &&
        /,\d{1,3}\s*(kilo|gram|k|g|ounce|oz|lb|pound|onces|livres)/i.test(value)
      ) {
        value = value.replace(",", "."); // 将逗号替换为点
      } else if (value.split(",").length - 1 > 1) {
        value = value.replace(/,/g, ""); // 移除千位分隔符
      }
    }

    // 支持阿拉伯语单位（沙特站点）
    if (marketplace === "SAU") {
      value = value.replace("،", "."); // 阿拉伯语逗号转点号
    }
  }

  // 处理磅(lb/pound)
  if (/lb|pound|livres/i.test(value)) {
    const match = value.match(/(\d+\.?\d*)/);
    if (match) {
      const value = parseFloat(match[1]);
      const gValue = Math.round(value * 453.592); // 转换为克并取整
      return gValue;
    }
  }
  // 处理盎司(oz/ounce)
  else if (/oz|ounce|onces/i.test(value)) {
    const match = value.match(/(\d+\.?\d*)/);
    if (match) {
      const value = parseFloat(match[1]);
      const gValue = Math.round(value * 28.3495); // 转换为克并取整
      return gValue;
    }
  }
  // 处理千克(kg/kilogram/kilogramos)
  else if (/kg|kilogram|kilogramos/i.test(value)) {
    const match = value.match(/(\d+\.?\d*)/);
    if (match) {
      const value = parseFloat(match[1]);
      const gValue = Math.round(value * 1000); // 千克转克
      return gValue;
    }
  }
  // 处理克(g/gram/gramos)
  else if (/g|gram|gramos/i.test(value)) {
    const match = value.match(/(\d+\.?\d*)/);
    if (match) {
      const value = parseFloat(match[1]);
      return Math.round(value); // 直接作为克返回
    } else {
      try {
        // 处理如"5000"这样的纯数字
        const numberPart = value.match(/(\d+(?:\.\d+)?)/);
        if (numberPart) {
          return Math.round(parseFloat(numberPart[1]));
        }
        return Math.round(parseFloat(value.split(" ")[0])); // 尝试提取第一个数字
      } catch (e) {
        return 0;
      }
    }
  }

  // 默认尝试提取纯数字（如"1.2"）
  const match = value.match(/(\d+\.?\d*)/);
  if (match) {
    return Math.round(parseFloat(match[1]));
  }

  return 0; // 默认返回 0 表示未识别到有效重量
}

export function normalizeWeightInSize(text: string, marketplace?: string): any {
  let value = cleanString(text);
  if (marketplace) {
    if (["MEX", "FRA", "DEU"].includes(marketplace)) {
      // 将逗号替换为点，但要确保不会影响千位分隔符
      // 例如："5,2 Kilogramos" -> "5.2 kilogramos"
      // 但 "5,200 Gramos" -> "5200 gramos"
      if (
        value.split(",").length - 1 === 1 &&
        /,\d{1,3}\s*(kilo|gram|k|g|ounce|oz|lb|pound|onces|livres)/i.test(value)
      ) {
        value = value.replace(",", "."); // 将逗号替换为点
      } else if (value.split(",").length - 1 > 1) {
        value = value.replace(/,/g, ""); // 移除千位分隔符
      }
    }

    // 支持阿拉伯语单位（沙特站点）
    if (marketplace === "SAU") {
      value = value.replace("،", "."); // 阿拉伯语逗号转点号
    }
  }

  // 处理磅(lb/lbs/pound/pounds) - 整合 extractPoundsToGrams 的逻辑
  // 支持 "Pounds"（大写P，复数形式）以及其他形式，支持逗号或点作为小数点
  if (/lb|pound|livres/i.test(value)) {
    // 正则表达式：匹配数值（支持整数、小数，小数点可用.或,）+ 可选空格 + 磅单位
    const match = value.match(/(\d+[.,]?\d*)\s*(lb|lbs|pound|pounds|livres)/i);
    if (match) {
      // 提取数值部分，处理可能的逗号作为小数点的情况（如欧洲格式）
      let poundsStr = match[1].replace(",", ".");
      const pounds = parseFloat(poundsStr);
      if (!isNaN(pounds)) {
        // 转换为克（1磅 = 453.59237克）
        const grams = pounds * 453.59237;
        return Math.round(grams);
      }
    }
  }
  // 处理盎司(oz/ounce) - 支持逗号或点作为小数点，能从包含尺寸信息的字符串中提取
  else if (/oz|ounce/i.test(value)) {
    // 正则表达式：匹配数值（支持整数、小数，小数点可用.或,）+ 可选空格 + 盎司单位
    const match = value.match(/(\d+[.,]?\d*)\s*(oz|ounce)/i);
    if (match) {
      // 提取数值部分，处理可能的逗号作为小数点的情况（如欧洲格式）
      let ouncesStr = match[1].replace(",", ".");
      const ounces = parseFloat(ouncesStr);
      if (!isNaN(ounces)) {
        // 转换为克（1盎司 = 28.3495克）
        const grams = ounces * 28.3495;
        return Math.round(grams);
      }
    }
  }
  // 处理千克(kg/kilogram/kilogramos) - 支持逗号或点作为小数点
  else if (/kg|kilogram|kilogramos/i.test(value)) {
    // 正则表达式：匹配数值（支持整数、小数，小数点可用.或,）+ 可选空格 + 千克单位
    const match = value.match(/(\d+[.,]?\d*)\s*(kg|kilogram|kilogramos)/i);
    if (match) {
      // 提取数值部分，处理可能的逗号作为小数点的情况（如欧洲格式）
      let kgStr = match[1].replace(",", ".");
      const kg = parseFloat(kgStr);
      if (!isNaN(kg)) {
        // 转换为克（1千克 = 1000克）
        const grams = kg * 1000;
        return Math.round(grams);
      }
    }
  }
  // 处理克(g/gram/gramos) - 支持逗号或点作为小数点
  else if (/g|gram|gramos/i.test(value)) {
    // 正则表达式：匹配数值（支持整数、小数，小数点可用.或,）+ 可选空格 + 克单位
    const match = value.match(/(\d+[.,]?\d*)\s*(g|gram|gramos)/i);
    if (match) {
      // 提取数值部分，处理可能的逗号作为小数点的情况（如欧洲格式）
      let gramsStr = match[1].replace(",", ".");
      const grams = parseFloat(gramsStr);
      if (!isNaN(grams)) {
        return Math.round(grams); // 直接作为克返回
      }
    } else {
      try {
        // 处理如"5000"这样的纯数字
        const numberPart = value.match(/(\d+[.,]?\d*)/);
        if (numberPart) {
          let numStr = numberPart[1].replace(",", ".");
          return Math.round(parseFloat(numStr));
        }
        return Math.round(parseFloat(value.split(" ")[0])); // 尝试提取第一个数字
      } catch (e) {
        return 0;
      }
    }
  }

  // 默认尝试提取纯数字（如"1.2"或"1,2"）
  const match = value.match(/(\d+[.,]?\d*)/);
  if (match) {
    let numStr = match[1].replace(",", ".");
    return Math.round(parseFloat(numStr));
  }

  return 0; // 默认返回 0 表示未识别到有效重量
}

// 辅助函数：单位转换为厘米
export function convertToCm(value: number, unit?: string): number {
  if (!unit) return value;

  // 关键修复：归一化单位（移除重音并转小写）
  const normalizedUnit = unit
    .toLowerCase()
    .replace(/è/g, "e") // 处理 è → e
    .replace(/é/g, "e") // 处理 é → e
    .replace(/â/g, "a") // 扩展其他可能的重音
    .replace(/ô/g, "o");

  switch (normalizedUnit) {
    // 归一化后，mètres 会变成 "metres"，与下面的case匹配
    case "metres":
    case "meters":
    case "m":
      return value * 100;
    case "mm":
    case "millimetres":
      return value / 10;
    case "in":
    case "inches":
    case '"':
      return value * 2.54;
    default: // cm/centimetres 或无单位
      return value;
  }
}

const UNIT_LIST = [
  "cm",
  "centimetres",
  "centimètres", // 厘米（英法）
  "mm",
  "millimetres",
  "millimètres", // 毫米（英法）
  "in",
  "inches",
  '"', // 英寸
  "metres",
  "meters",
  "m",
  "mètres",
  "mètres", // 米（英法，带重音）
];
// 生成单位正则字符串（用 | 连接，适配全局和局部匹配）
const UNIT_REGEX_STR = UNIT_LIST.join("|");
function processDimensions(processedStr: string): string[] {
  // 全局单位匹配：使用常量生成的正则
  const globalUnitMatch = processedStr.match(
    new RegExp(`\\s*(${UNIT_REGEX_STR})\\s*$`, "i")
  );
  const globalUnit = globalUnitMatch?.[1];

  // 移除全局单位
  const valueStr = globalUnit
    ? processedStr.replace(new RegExp(`\\s*${globalUnit}\\s*$`, "i"), "")
    : processedStr;
  const parts = valueStr.split(/\s*[xX×]\s*/);

  const cleanedParts: string[] = [];

  for (const part of parts) {
    // 数值匹配（提取纯数字）
    const valueMatch = part.match(/(\d+\.?\d*)/);
    if (valueMatch) {
      const value = parseFloat(valueMatch[1]);
      // 局部单位匹配：使用同一常量生成的正则
      const localUnitMatch = part.match(new RegExp(`(${UNIT_REGEX_STR})`, "i"));
      const unit = localUnitMatch?.[1] || globalUnit;

      const converted = convertToCm(value, unit);
      cleanedParts.push(`${converted.toFixed(2)}cm`);
    }
  }

  return cleanedParts;
}

/**
 * 标准化澳大利亚站点尺寸，统一转换为 "cm x cm x cm" 格式
 * @param dimensionsStr 原始尺寸字符串
 * @returns 标准化后的尺寸字符串，未匹配则返回空字符串
 */
export function normalizeDimensions(
  dimensionsStr: string,
  marketplace: string
): string {
  let processedStr = cleanString(dimensionsStr);

  // 分割并保留分号前的尺寸部分（排除重量等其他信息）
  if (processedStr.includes(";")) {
    processedStr = processedStr.split(";")[0].trim();
  }
  if (marketplace === "DEU") {
    processedStr = processedStr.replace(/ /g, "").replace(/,/g, ".").trim();
  } else if (marketplace === "FRA") {
    processedStr = processedStr.replace(/ /g, "").replace(/,/g, ".").trim();
  }

  // 模式1：处理包含 L/W/Th 标识符的格式（如 "2.03L x 1.07W x 0.22Th metres"）
  const lwtPattern =
    /(\d+\.?\d*)\s*[Ll]\s*[xX×]\s*(\d+\.?\d*)\s*[Ww]\s*[xX×]\s*(\d+\.?\d*)\s*[Tt][Hh]?\s*(metres|meters|m|centimetres|cm|mm|millimetres|in|inches|")?/;
  const lwtMatch = processedStr.match(lwtPattern);
  if (lwtMatch) {
    const [, dim1, dim2, dim3, unit] = lwtMatch;
    const d1 = convertToCm(parseFloat(dim1), unit);
    const d2 = convertToCm(parseFloat(dim2), unit);
    const d3 = convertToCm(parseFloat(dim3), unit);
    return `${d1.toFixed(2)}cm x ${d2.toFixed(2)}cm x ${d3.toFixed(2)}cm`;
  }

  // 模式2：通用三维尺寸格式（如 "20D x 20W x 20H cm"）
  const generalPattern =
    /(\d+\.?\d*)\s*[DdWwHhLl]?\s*[xX×]\s*(\d+\.?\d*)\s*[DdWwHhLl]?\s*[xX×]\s*(\d+\.?\d*)\s*[DdWwHhTtLl]?[Hh]?\s*(cm|centimetres|mm|millimetres|in|inches|"|metres|meters|m)?/i;
  const generalMatch = processedStr.match(generalPattern);
  if (generalMatch) {
    const [, dim1, dim2, dim3, unit] = generalMatch;
    const d1 = convertToCm(parseFloat(dim1), unit);
    const d2 = convertToCm(parseFloat(dim2), unit);
    const d3 = convertToCm(parseFloat(dim3), unit);
    return `${d1.toFixed(2)}cm x ${d2.toFixed(2)}cm x ${d3.toFixed(2)}cm`;
  }

  // 模式3：每部分带独立单位的格式（如 "20cm x 30in x 5m"）
  const multiUnitPattern =
    /(\d+\.?\d*)\s*[DdWwHhLl]?\s*(cm|centimetres|mm|millimetres|in|inches|"|metres|meters|m)\s*[xX×]\s*(\d+\.?\d*)\s*[DdWwHhLl]?\s*(cm|centimetres|mm|millimetres|in|inches|"|metres|meters|m)\s*[xX×]\s*(\d+\.?\d*)\s*[DdWwHhTtLl]?[Hh]?\s*(cm|centimetres|mm|millimetres|in|inches|"|metres|meters|m)/i;
  const multiUnitMatch = processedStr.match(multiUnitPattern);
  if (multiUnitMatch) {
    const [, dim1, unit1, dim2, unit2, dim3, unit3] = multiUnitMatch;
    const d1 = convertToCm(parseFloat(dim1), unit1);
    const d2 = convertToCm(parseFloat(dim2), unit2);
    const d3 = convertToCm(parseFloat(dim3), unit3);
    return `${d1.toFixed(2)}cm x ${d2.toFixed(2)}cm x ${d3.toFixed(2)}cm`;
  }

  // 模式4：兜底分割处理（如 "20 x 30 x 40 inches" 拆分后转换）
  const cleanedParts = processDimensions(processedStr);

  return cleanedParts.length > 0 ? cleanedParts.join(" x ") : "";
}

/**
 * 标准化价格文本为统一格式（如 "19.99" 或 "4980"）
 * @param text 原始价格文本
 * @param marketplace 市场标识符（如 JPN、DEU、CAN、MEX）
 * @return 标准化后价格字符串
 */
export function normalizePrice(text: string, marketplace?: string): string {
  // 移除非数字和小数点/逗号
  let cleaned = text.trim().replace(/[^\d.,]/g, "");

  // 判断地区格式
  if (marketplace === "DEU" || text.includes("€")) {
    // 欧元区：19,99 → 19.99
    cleaned = cleaned.replace(/,/g, ".");
    const parts = cleaned.split(".");
    if (parts.length > 1) {
      return `${parts.slice(0, -1).join("")}.${parts[parts.length - 1]}`;
    }
    return cleaned;
  } else if (marketplace === "JPN" || text.includes("¥")) {
    const cleanedJp = text.replace(/[^\d,]/g, "").trim();

    // 匹配类似 "6,710" 或 "4980"
    const match = cleanedJp.match(/(\d{1,3}(?:,\d{3})*)/);
    if (match) {
      // 去掉逗号返回纯数字
      return match[1].replace(/,/g, "");
    } else {
      // 最后尝试直接提取连续数字
      const numMatch = cleanedJp.match(/\d+/);
      return numMatch ? numMatch[0] : "";
    }
  } else if (
    ["GBR", "USA", "CAN", "MEX"].includes(marketplace || "") ||
    text.includes("£") ||
    text.includes("$")
  ) {
    // 英镑/美元/加元/比索：12.99
    // 对于MEX, USA, CAN，需要处理如"1,128.99"的格式（逗号为千位分隔符，点为小数点）
    if (["USA", "CAN", "MEX"].includes(marketplace || "")) {
      // 移除千位分隔符逗号
      cleaned = cleaned.replace(/,/g, "");
      // 匹配整数和小数部分
      const match = cleaned.match(/\d+(?:\.\d+)?/);
      return match ? match[0] : "";
    } else if (marketplace === "GBR") {
      // 英国市场也使用点作为小数点，逗号作为千位分隔符
      cleaned = cleaned.replace(/,/g, "");
      const match = cleaned.match(/\d+(?:\.\d+)?/);
      return match ? match[0] : "";
    } else {
      const match = cleaned.match(/\d+(?:\.\d+)?/);
      return match ? match[0] : "";
    }
  } else {
    // 默认尝试提取数字和小数点
    const match = cleaned.match(/\d+(?:[.,]\d+)*/);
    if (match) {
      let numStr = match[0];
      if (numStr.includes(",") && numStr.includes(".")) {
        // 处理可能的千分位和小数点混淆
        numStr = numStr.replace(/,/g, "");
      } else if (numStr.includes(",")) {
        numStr = numStr.replace(/,/g, ".");
      }
      return numStr;
    }
    return cleaned;
  }
}
